#pragma once

#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <cstring>
#include <ctime>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <functional>
#include <sys/epoll.h>
#include <unordered_map>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <sys/timerfd.h>
#include <sys/eventfd.h>
#include <memory>

using namespace std;

// #define BUFFER_DEFAULT_SIZE 1024

// #define INF 0
// #define DBG 1
// #define ERR 2

// #define LOG_LEVEL ERR
// #define LOG(level, format, ...)                                                                                           \
//     do                                                                                                                    \
//     {                                                                                                                     \
//         if (level < LOG_LEVEL)                                                                                            \
//             break;                                                                                                        \
//         time_t t = time(NULL);                                                                                            \
//         struct tm *tinfo = localtime(&t);                                                                                 \
//         char tmp[32] = {0};                                                                                               \
//         strftime(tmp, 31, "%H:%M:%S", tinfo);                                                                             \
//         fprintf(stdout, "[%p][%s][%s : %d]" format "\n", (void *)pthread_self(), tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
//     } while (0)

// #define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
// #define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
// #define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)


// class Any
// {
// private:
//     class holder
//     {
//     public:
//         virtual ~holder() {}
//         virtual const std::type_info &type() = 0;
//         virtual holder *clone() = 0;
//     };

//     template <class T>
//     class placeholder : public holder
//     {
//     public:
//         placeholder(const T &val) : _val(val) {}
//         // 获取子类对象保存的数据类型
//         virtual const std::type_info &type()
//         {
//             return typeid(T);
//         }
//         // 针对当前的对象自身，克隆出一个新的子类对象
//         virtual holder *clone()
//         {
//             return new placeholder<T>(_val);
//         }

//     public:
//         T _val;
//     };
//     holder *_content;

// public:
//     // 无参构造
//     Any() : _content(nullptr) {}
//     // 值构造
//     template <class T>
//     Any(const T &val) : _content(new placeholder<T>(val)) {}
//     // 对象构造
//     Any(const Any &other) : _content(_content ? other._content->clone() : nullptr) {}
//     ~Any()
//     {
//         delete _content;
//     }

//     void swap(Any &other)
//     {
//         std::swap(_content, other._content);
//     }

//     // 返回子类对象保存的数据指针
//     template <class T>
//     T *get()
//     {
//         assert(typeid(T) == _content->type());

//         return &((placeholder<T> *)_content)->_val;
//     }
//     // 赋值运算符重载
//     template <class T>
//     Any &operator=(const T &val)
//     {
//         Any(val).swap(*this);
//         return *this;
//     }
//     Any &operator=(const Any &other)
//     {
//         Any(other).swap(*this);
//         return *this;
//     }
// };

// class Buffer
// {
// private:
//     std::vector<char> _buffer; // 使用vector作为缓冲区
//     uint64_t _reader_idx;      // 读偏移
//     uint64_t _writer_idx;      // 写偏移
// public:
//     Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}

//     char *Begin()
//     {
//         return &*_buffer.begin();
//     }
//     // 获取当前写入起始地址
//     char *WritePosition()
//     {
//         return Begin() + _writer_idx;
//     }
//     // 获取当前读取起始地址
//     char *ReadPosition()
//     {
//         return Begin() + _reader_idx;
//     }
//     // 获取缓冲区末尾空闲空间大小--写偏移之后的空间
//     uint64_t TailIdleSize()
//     {
//         return _buffer.size() - _writer_idx;
//     }
//     // 获取缓冲区头部空闲空间大小--读偏移之前的空间
//     uint64_t HeadIdleSize()
//     {
//         return _reader_idx;
//     }
//     // 获取可读数据大小
//     uint64_t ReadableSize()
//     {
//         return _writer_idx - _reader_idx;
//     }
//     // 将读偏移向后移动
//     void MoveReadOffset(uint64_t len)
//     {
//         if (len == 0)
//             return;
//         assert(len <= ReadableSize());

//         _reader_idx += len;
//     }
//     // 将写偏移向后移动
//     void MoveWriteOffset(uint64_t len)
//     {
//         assert(len <= TailIdleSize());
//         // EnsureWriteSpace(len);
//         _writer_idx += len;
//     }
//     // 确保可写空间足够（足够则移动数据，不够则扩容）
//     void EnsureWriteSpace(uint64_t len)
//     {
//             _reader_idx = 0;
//             _writer_idx = rsz;
//         }
//         else // 扩容
//         {
//             _buffer.resize(_buffer.size() + len);
//         }
//     }
//     // 写入数据
//     void Write(const void *data, uint64_t len)
//     {
//         if (len == 0)
//             return;
//         // 1.确保可写空间足够
//         EnsureWriteSpace(len);
//         // 2.写入数据
//         std::copy((char *)data, (char *)data + len, WritePosition());
//     }

//     void WriteAndPush(const void *data, uint64_t len)
//     {
//         Write(data, len);
//     }

//     void WriteStringAndPush(const std::string &data)
//     {
//         // cout << "before:" << _buffer.size() << endl;
//         WriteString(data);
//         // cout << "after:" << _buffer.size() << endl;
//         MoveWriteOffset(data.size());
//     }

//     void WriteBuffer(Buffer &data)
//     {
//         Write(data.ReadPosition(), data.ReadableSize());
//     }

//     void WriteBufferAndPush(Buffer &data)
//     {

//         WriteBuffer(data);

//         MoveWriteOffset(data.ReadableSize());
//     }

//     // 读取数据
//     void Read(void *buf, uint64_t len)
//     {
//         // 1.确保可读数据足够
//         assert(len <= ReadableSize());
//         // 2.读取数据
//         std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
//     }

//     void ReadAndPop(void *buf, uint64_t len)
//     {
//         Read(buf, len);
//         MoveReadOffset(len);
//     }
//     std::string ReadString(uint64_t len)
//     {
//         assert(len <= ReadableSize());
//         std::string str;
//         str.resize(len);
//         Read(&str[0], len);
//         return str;
//     }

//     std::string ReadStringAndPop(uint64_t len)
//     {
//         std::string str = ReadString(len);
//         MoveReadOffset(len);
//         return str;
//     }

//     // 寻找换行符
//     char *FindCRLF()
//     {
//         void *res = memchr(ReadPosition(), '\n', ReadableSize());
//         return (char *)res;
//     }

//     // 获取一行数据
//     std::string GetLine()
//     {
//         char *pos = FindCRLF();
//         if (pos == nullptr)
//             return "";
//         return ReadString(pos - ReadPosition() + 1);
//     }

//     std::string GetLineAndPop()
//     {
//         std::string str = GetLine();
//         MoveReadOffset(str.size());
//         return str;
//     }

//     // 清除数据
//     void Clear()
//     {
//         _writer_idx = 0;
//         _reader_idx = 0;
//     }
// };

// #define MAX_LISTEN 1024

// class Socket
// {
// private:
//     int _sockfd;

// public:
//     Socket() : _sockfd(-1) {}
//     Socket(int fd) : _sockfd(fd) {}
//     ~Socket()
//     {
//         Close();
//     }
//     int Fd()
//     {
//         return _sockfd;
//     }
//     // 创建套接字
//     bool Create()
//     {
//         _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
//         if (_sockfd < 0)
//         {
//             ERR_LOG("socket error");
//             return false;
//         }
//         return true;
//     }
//     // 绑定地址信息
//     bool Bind(const std::string &ip, const uint16_t &port)
//     {
//         struct sockaddr_in addr;
//         addr.sin_family = AF_INET;
//         addr.sin_port = htons(port);
//         addr.sin_addr.s_addr = inet_addr(ip.c_str());
//         int ret = bind(_sockfd, (struct sockaddr *)&addr, sizeof(addr));
//         if (ret < 0)
//         {
//             ERR_LOG("bind error");
//             return false;
//         }
//         return true;
//     }
//     // 开始监听
//     bool Listen(int backlog = MAX_LISTEN) // 同一时间最大并发连接数
//     {
//         int ret = listen(_sockfd, backlog);
//         if (ret < 0)
//         {
//             ERR_LOG("listen error");
//             return false;
//         }
//         return true;
//     }
//     // 向服务器发起连接
//     bool Connect(const std::string &ip, const uint16_t &port)
//     {
//         struct sockaddr_in addr;
//         addr.sin_family = AF_INET;
//         addr.sin_port = htons(port);
//         addr.sin_addr.s_addr = inet_addr(ip.c_str());
//         int ret = connect(_sockfd, (struct sockaddr *)&addr, sizeof(addr));
//         if (ret < 0)
//         {
//             ERR_LOG("connect error");
//             return false;
//         }
//         return true;
//     }
//     // 获取连接
//     int Accept()
//     {
//         int newfd = accept(_sockfd, NULL, NULL);
//         if (newfd < 0)
//         {
//             ERR_LOG("accept error");
//             return -1;
//         }
//         return newfd;
//     }
//     // 接收数据
//     size_t Recv(void *buf, size_t len, int flag = 0)
//     {
//         size_t ret = recv(_sockfd, buf, len, flag);
//         if (ret <= 0)
//         {
//             // EAGAIN:非阻塞模式下，接收缓冲区没有数据可读
//             // EINTERR:被信号中断
//             if (errno == EAGAIN || errno == EINTR)
//                 return 0;
//             else
//             {
//                 ERR_LOG("recv error");
//                 return -1;
//             }
//         }
//         return ret;
//     }

//     size_t NonBlockRecv(void *buf, size_t len)
//     {
//         size_t ret = recv(_sockfd, buf, len, MSG_DONTWAIT);
//         return ret;
//     }

//     // 发送数据
//     size_t Send(void *buf, size_t len, int flag = 0)
//     {
//         if (len == 0)
//             return 0;
//         size_t ret = send(_sockfd, buf, len, flag);
//         if (ret < 0)
//         {
//             if (errno == EAGAIN || errno == EINTR)
//                 return 0;
//             ERR_LOG("send error");
//             return -1;
//         }
//         return ret;
//     }

//     size_t NonBlockSend(void *buf, size_t len)
//     {

//         size_t ret = send(_sockfd, buf, len, MSG_DONTWAIT);
//         return ret;
//     }

//     // 关闭套接字
//     void Close()
//     {
//         if (_sockfd != -1)
//         {
//             close(_sockfd);
//             _sockfd = -1;
//         }
//     }
//     // 创建一个服务端连接
//     bool CreateServer(const uint16_t &port, const std::string &ip = "0.0.0.0", bool flag = false)
//     {
//         // 1.创建套接字
//         if (!Create())
//             return false;
//         // 2.设置非阻塞
//         // if (flag)
//         //     NonBlock();
//         // 3.绑定地址
//         if (!Bind(ip, port))
//             return false;
//         // 4.开始监听
//         if (!Listen())
//             return false;
//         // 5.设置地址端口重用
//         ReuseAddress();
//         return true;
//     }
//     // 创建一个客户端连接
//     bool CreateClient(const uint16_t &port, const std::string &ip)
//     {
//         // 1.创建套接字
//         if (!Create())
//             return false;
//         // 2.连接服务器
//         if (!Connect(ip, port))
//             return false;
//         return true;
//     }
//     // 设置套接字选项--开启地址端口重用
//     void ReuseAddress()
//     {
//         int val = 1;
//         setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
//         val = 1;
//         setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
//     }
//     // 设置套接字阻塞属性--设置为非阻塞
//     void NonBlock()
//     {
//         int flag = fcntl(_sockfd, F_GETFL, 0);

//         fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
//     }
// };

// class Poller;
// class EventLoop;

// class Channel
// {
// private:
//     int _fd;
//     EventLoop *_loop;
//     uint32_t _events;  // 当前需要监控的事件
//     uint32_t _revents; // 当前连接触发的事件
//     using EventCallback = std::function<void()>;
//     EventCallback _read_callback;
//     EventCallback _write_callback;
//     EventCallback _error_callback;
//     EventCallback _close_callback;
//     EventCallback _event_callback;

// public:
//     Channel(EventLoop *loop, int fd) : _loop(loop), _fd(fd), _events(0), _revents(0) {}

//     int Fd()
//     {
//         return _fd;
//     }

//     // 获取想要监控的事件
//     uint32_t Events()
//     {
//         return _events;
//     }

//     // 设置实际就绪的事件
//     void SetRevents(uint32_t events)
//     {
//         _revents = events;
//     }
//     void SetReadCallback(const EventCallback &cb)
//     {
//         _read_callback = cb;
//     }
//     void SetWriteCallback(const EventCallback &cb)
//     {
//         _write_callback = cb;
//     }
//     void SetErrorCallback(const EventCallback &cb)
//     {
//         _error_callback = cb;
//     }
//     void SetCloseCallback(const EventCallback &cb)
//     {
//         _close_callback = cb;
//     }
//     void SetEventCallback(const EventCallback &cb)
//     {
//         _event_callback = cb;
//     }

//     // 当前是否监控了可读
//     bool Readable()
//     {
//         return _events & EPOLLIN;
//     }
//     // 当前是否监控了可写
//     bool WriteAble()
//     {
//         return _events & EPOLLOUT;
//     }
//     // 启动读事件监控
//     void EnableRead()
//     {
//         _events |= EPOLLIN;
//         Update();
//     }
//     // 启动写事件监控
//     void EnableWrite()
//     {
//         _events |= EPOLLOUT;
//         Update();
//     }
//     // 关闭读事件监控
//     void DisableRead()
//     {
//         _events &= ~EPOLLIN;
//         Update();
//     }
//     // 关闭写事件监控
//     void DisableWrite()
//     {
//         _events &= ~EPOLLOUT;
//         Update();
//     }
//     // 关闭所有事件监控
//     void DisableAll()
//     {
//         _events = 0;
//         Update();
//     }
//     // 移除事件监控
//     void Remove();
//     void Update();
//     // 事件处理，一旦连接触发了事件，就调用这个函数
//     void HandleEvent()
//     {
//         // EPOLLIN: 可读事件
//         // EPOLLRDHUP: 对方关闭连接
//         // EPOLLPRI: 紧急(优先)数据可读
//         if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
//         {
//             if (_event_callback)
//                 _event_callback();
//             if (_read_callback)
//                 _read_callback();
//         }

//         // EPOLLOUT: 可写事件
//         if ((_revents & EPOLLOUT))
//         {
//             if (_event_callback)
//                 _event_callback();
//             if (_write_callback)
//                 _write_callback();
//         }
//         else if ((_revents & EPOLLERR)) // EPOLLERR: 错误事件
//         {
//             if (_event_callback)
//                 _event_callback();
//             if (_error_callback)
//                 _error_callback();
//         }
//         else if ((_revents & EPOLLHUP)) // EPOLLHUB: 连接关闭事件
//         {
//             if (_event_callback)
//                 _event_callback();
//             if (_close_callback)
//                 _close_callback();
//         }

//         // if(_event_callback)
//         //     _event_callback();
//     }
// };

// #define EPOLL_SIZE 1024

// class Poller
// {
// private:
//     int _epfd;
//     struct epoll_event _evs[EPOLL_SIZE];
//     std::unordered_map<int, Channel *> _channels;

// private:
//     void Update(Channel *channel, int op)
//     {
//         int fd = channel->Fd();
//         struct epoll_event ev;
//         ev.data.fd = fd;
//         ev.events = channel->Events();
//         int ret = epoll_ctl(_epfd, op, fd, &ev);
//         if (ret < 0)
//         {
//             ERR_LOG("epoll_ctl error");
//         }
//     }
//     // 判断一个Channel是否添加了事件监控
//     bool HasChannel(Channel *channel)
//     {
//         auto it = _channels.find(channel->Fd());
//         if (it == _channels.end())
//             return false;
//         return true;
//     }

// public:
//     Poller()
//     {
//         _epfd = epoll_create(EPOLL_SIZE);
//         if (_epfd < 0)
//         {
//             ERR_LOG("epoll_create error");
//             abort();
//         }
//     }
//     void UpdateEvent(Channel *channel)
//     {
//         bool ret = HasChannel(channel);
//         if (ret == false)
//         {
//             _channels.insert(std::make_pair(channel->Fd(), channel));
//             Update(channel, EPOLL_CTL_ADD);
//         }
//         else
//             Update(channel, EPOLL_CTL_MOD);
//     }
//     void RemoveEvent(Channel *channel)
//     {
//         auto it = _channels.find(channel->Fd());
//         if (it != _channels.end())
//             _channels.erase(it);
//         Update(channel, EPOLL_CTL_DEL);
//     }
//     // 开始监控，返回活跃连接
//     void Poll(std::vector<Channel *> *active)
//     {
//         int nfds = epoll_wait(_epfd, _evs, EPOLL_SIZE, -1);
//         if (nfds < 0)
//         {
//             if (errno == EINTR)
//                 return;
//             ERR_LOG("epoll_wait error : %s", strerror(errno));
//             abort();
//         }

//         for (int i = 0; i < nfds; i++)
//         {
//             auto it = _channels.find(_evs[i].data.fd);
//             assert(it != _channels.end());
//             it->second->SetRevents(_evs[i].events);
//             active->push_back(it->second);
//         }
//     }
// };

// // 设计定时任务类
// using TaskFunc = std::function<void()>;
// using ReleaseFunc = std::function<void()>;
// class TimerTask
// {
// private:
//     uint64_t _id;            // 定时器任务id
//     uint32_t _timeout;       // 定时任务的超时时间
//     bool _canceled;          // false表示定时任务还未被取消 , true表示定时任务已经被取消
//     TaskFunc _task_cb;       // 定时器对象要执行的定时任务
//     ReleaseFunc _release_cb; // 用于删除TimerWheel中保存的定时器对象信息
// public:
//     TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb)
//         : _id(id),
//           _timeout(delay),
//           _canceled(false),
//           _task_cb(cb)
//     {
//     }
//     ~TimerTask()
//     {
//         if (_canceled == false)
//             _task_cb();
//         _release_cb();
//     }

//     void SetRealseFunc(const ReleaseFunc &cb)
//     {
//         _release_cb = cb;
//     }

//     uint32_t DelayTime()
//     {
//         return _timeout;
//     }

//     void Cancel()
//     {
//         _canceled = true;
//     }
// };

// // 时间轮设计

// class TimerWheel
// {
// private:
//     using WeakTask = std::weak_ptr<TimerTask>;  // 如果shared_ptr是针对原始对象构建的，那么计数器就不会增加，这样就会出现问题
//     using PtrTask = std::shared_ptr<TimerTask>; // 由智能指针来管理定时任务，计数器降到0则销毁对象，并执行定时任务
//     int _tick;                                  // 秒针，走到哪里就释放哪里，就执行哪里的任务
//     int _capacity;                              // 表盘最大数量，即为最大延迟时间
//     std::vector<std::vector<PtrTask>> _wheel;   // 时间轮
//     std::unordered_map<uint64_t, WeakTask> _timers;

//     EventLoop *_loop;
//     int _timerfd;
//     std::unique_ptr<Channel> _timer_channel;

// private:
//     void RemoveTimer(uint64_t id)
//     {
//         auto it = _timers.find(id);
//         if (it != _timers.end())
//         {
//             _timers.erase(it);
//         }
//     }

//     static int CreateTimerFd()
//     {
//         // int timerfd_create(int clockid, int flags);
//         int timerfd = timerfd_create(CLOCK_MONOTONIC, 0); // 创建定时器
//         if (timerfd < 0)
//         {
//             perror("timerfd_create error");
//             return -1;
//         }

//         //    struct timespec
//         //    {
//         //          time_t tv_sec; /* Seconds */
//         //          long tv_nsec;  /* Nanoseconds */
//         //    };
//         //    struct itimerspec
//         //    {
//         //          struct timespec it_interval; /* Interval for periodic timer */
//         //           struct timespec it_value;    /* Initial expiration */
//         //    };
//         struct itimerspec itime;
//         // 设置第一次超时时间
//         itime.it_value.tv_sec = 1;
//         itime.it_value.tv_nsec = 0;
//         // 设置间隔超时时间
//         itime.it_interval.tv_sec = 1;
//         itime.it_interval.tv_nsec = 0;

//         // int timerfd_settime(int fd, int flags,const struct itimerspec *new_value,struct itimerspec *old_value);
//         timerfd_settime(timerfd, 0, &itime, NULL); // 启动定时器
//         return timerfd;
//     }

//     int ReadTimeFd()
//     {
//         uint64_t times;
//         int ret = read(_timerfd, &times, sizeof(times));
//         if (ret < 0)
//         {
//             ERR_LOG("read timerfd error");
//             abort();
//         }
//         return times;
//     }

//     // 执行定时任务，每隔一秒执行一次，相当于秒针向后走了一步，秒针走到哪里，就执行哪里的定时任务
//     void RunTimerTask()
//     {
//         _tick = (_tick + 1) % _capacity;
//         _wheel[_tick].clear(); // 清除指定位置的数组，就会把数组中保存的所有定时器管理对象的shared_ptr释放掉
//     }

//     void OnTime()
//     {
//         //根据实际超时的次数，执行对应的超时任务
//         int times=ReadTimeFd();
//         for(int i=0;i<times;i++)
//         {
//             RunTimerTask();
//         }
//     }

//     void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
//     {
//         // 创建定时任务，并用shared_ptr管理
//         PtrTask pt(new TimerTask(id, delay, cb));
//         pt->SetRealseFunc(std::bind(&TimerWheel::RemoveTimer, this, id));
//         int pos = (_tick + delay) % _capacity;
//         _wheel[pos].push_back(pt);  // 把定时任务对象加入到时间轮中
//         _timers[id] = WeakTask(pt); // 把定时任务对象加入到哈希表中，管理定时任务对象(shared_ptr<TimerTask>)
//     }

//     void TimerRefreshInLoop(uint64_t id)
//     {
//         auto it = _timers.find(id);
//         if (it == _timers.end()) // 没有找到定时任务，无法刷新/延迟
//             return;
//         PtrTask pt = it->second.lock(); // 获取weak_ptr管理的对象所对应的shared_ptr
//         uint32_t delay = pt->DelayTime();
//         int pos = (_tick + delay) % _capacity;
//         _wheel[pos].push_back(pt);
//     }

//     void TimerCancelInLoop(uint64_t id)
//     {
//         auto it = _timers.find(id);
//         if (it == _timers.end())
//             return;
//         PtrTask pt = it->second.lock();
//         pt->Cancel();
//     }

// public:
//     TimerWheel(EventLoop *loop)
//         : _tick(0),
//           _capacity(60),
//           _wheel(_capacity),
//           _loop(loop),
//           _timerfd(CreateTimerFd()),
//           _timer_channel(new Channel(_loop, _timerfd))
//     {
//         _timer_channel->SetEventCallback(std::bind(&TimerWheel::OnTime, this));
//         _timer_channel->EnableRead();
//     }
//     // 添加定时任务
//     void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);

//     // 刷新/延迟定时任务
//     void TimerRefresh(uint64_t id);

//     // 取消定时任务
//     void TimerCancel(uint64_t id);

//     // 存在线程安全问题
//     bool HasTimer(uint64_t id)
//     {
//         auto it = _timers.find(id);
//         if (it == _timers.end())
//             return false;
//         return true;
//     }
// };

// class EventLoop
// {
// private:
//     std::thread::id _thread_id;
//     int _event_fd;
//     std::unique_ptr<Channel> _event_channel; // 管理_event_fd
//     Poller _poller;

//     using Functor = std::function<void()>;
//     std::vector<Functor> _tasks;
//     std::mutex _mutex;

//     TimerWheel _timer_wheel;

// private:
//     void RunAllTask()
//     {
//         std::vector<Functor> functor;
//         {
//             std::unique_lock<std::mutex> lock(_mutex);
//             functor.swap(_tasks);
//         }
//         for (auto &f : functor)
//             f();
//     }

//     static int CreateEventFd()
//     {
//         // EFD_CLOEXEC: 创建的fd不会被子进程继承,禁止进程复制
//         // EFD_NONBLOCK: 创建的fd是非阻塞的
//         int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
//         if (efd < 0)
//         {
//             ERR_LOG("create eventfd error");
//             abort();
//         }
//         return efd;
//     }
//     void ReadEventFd()
//     {
//         uint64_t val = 1;
//         int ret = read(_event_fd, &val, sizeof(val));
//         if (ret < 0)
//         {
//             if (errno == EINTR || errno == EAGAIN)
//                 return;

//             ERR_LOG("read eventfd error");
//             abort();
//         }
//     }
//     void WakeUpEventFd()
//     {
//         uint64_t val = 1;
//         int ret = write(_event_fd, &val, sizeof(val));
//         if (ret < 0)
//         {
//             if (errno == EINTR)
//                 return;

//             ERR_LOG("write eventfd error");
//             abort();
//         }
//     }

// public:
//     EventLoop()
//         : _thread_id(std::this_thread::get_id()),
//           _event_fd(CreateEventFd()),
//           _event_channel(new Channel(this, _event_fd)),
//           _timer_wheel(this)
//     {
//         // 给eventfd添加可读事件回调，读取eventfd事件通知次数
//         _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this));
//         _event_channel->EnableRead();
//     }

//     // 事件监控->就绪事件处理 ->执行任务
//     void Start()
//     {
//         while (true)
//         {
//             // 1.事件监控
//             std::vector<Channel *> actives;
//             _poller.Poll(&actives);
//             // 2.就绪事件处理
//             for (auto &channel : actives)
//             {
//                 channel->HandleEvent();
//             }
//             // 3.执行任务
//             RunAllTask();
//         }
//     }

//     // 判断当前线程是否是EventLoop对应的线程
//     bool IsInLoop()
//     {
//         return _thread_id == std::this_thread::get_id();
//     }

//     void AssertInLoop()
//     {
//         assert(_thread_id == std::this_thread::get_id());
//     }

//     // 判断将要执行的任务是否处于当前线程中，存在则执行，不存在则压入任务队列
//     void RunInLoop(const Functor &cb)
//     {
//         if (IsInLoop())
//             cb();
//         else
//             QueueInLoop(cb);
//     }
//     // 将任务压入任务池
//     void QueueInLoop(const Functor &cb)
//     {
//         {
//             std::unique_lock<std::mutex> lock(_mutex);
//             _tasks.push_back(cb);
//         }
//         // 唤醒可能因为没有事件就绪而导致的epoll阻塞
//         // 即给eventfd写入一个数据，eventfd就会触发可读事件
//         WakeUpEventFd();
//     }

//     // 添加/修改描述符的事件监控
//     void UpdateEvent(Channel *channel)
//     {
//         _poller.UpdateEvent(channel);
//     }
//     // 移除描述符的监控
//     void RemoveEvent(Channel *channel)
//     {
//         _poller.RemoveEvent(channel);
//     }

//     void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
//     {
//         _timer_wheel.TimerAdd(id, delay, cb);
//     }

//     void TimerRefresh(uint64_t id)
//     {
//         _timer_wheel.TimerRefresh(id);
//     }

//     void TimerCancel(uint64_t id)
//     {
//         _timer_wheel.TimerCancel(id);
//     }

//     bool HasTimer(uint64_t id)
//     {
//         return _timer_wheel.HasTimer(id);
//     }
// };

// class LoopThread
// {
// private:
//     // 实现获取loop操作的同步 避免在loop实例化前就执行获取操作
//     std::mutex _mutex;
//     std::condition_variable _cond;
//     EventLoop *_loop;    // 在线程中实例化
//     std::thread _thread; //_loop对应的线程

// private:
//     // 线程的入口函数
//     // 实例化EventLoop对象 开始运行EventLoop模块的功能
//     void ThreadEntry()
//     {
//         EventLoop loop;
//         {
//             std::unique_lock<std::mutex> lock(_mutex);

//             _loop = &loop;
//             _cond.notify_all();
//         }
//         loop.Start();
//     }

// public:
//     // 创建线程 设置线程入口函数
//     LoopThread()
//         : _loop(nullptr),
//           _thread(std::thread(std::bind(&LoopThread::ThreadEntry, this)))
//     {
//     }

//     EventLoop *GetLoop()
//     {
//         EventLoop *loop = nullptr;
//         {
//             std::unique_lock<std::mutex> lock(_mutex);
//             _cond.wait(lock, [&]()
//                        { return _loop != nullptr; });

//             loop = _loop;
//         }
//         return loop;
//     }
// };

// class LoopThreadPool
// {
// private:
//     int _thread_count;
//     int _next_idx;
//     EventLoop *_baseloop;
//     std::vector<LoopThread *> _threads;
//     std::vector<EventLoop *> _loops;

// private:
// public:
//     LoopThreadPool(EventLoop *baseloop)
//         : _thread_count(0),
//           _next_idx(0),
//           _baseloop(baseloop)
//     {
//     }
//     void SetThreadCount(int count)
//     {
//         _thread_count = count;
//     }
//     void Create()
//     {
//         if (_thread_count > 0)
//         {
//             _threads.resize(_thread_count);
//             _loops.resize(_thread_count);
//             for (int i = 0; i < _thread_count; i++)
//             {
//                 _threads[i] = new LoopThread();
//                 _loops[i] = _threads[i]->GetLoop();
//             }
//         }
//     }
//     EventLoop *NextLoop()
//     {
//         if (_thread_count == 0)
//             return _baseloop;
//         _next_idx = (_next_idx + 1) % _thread_count;
//         return _loops[_next_idx];
//     }
// };

// class Connection;
// // DISCONECTED -- 连接关闭状态；   CONNECTING -- 连接建立成功-待处理状态
// // CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态；  DISCONNECTING -- 待关闭状态
// typedef enum
// {
//     DISCONNECTED,
//     CONNECTING,
//     CONNECTED,
//     DISCONNECTING
// } ConnStatu;
// using PtrConnection = std::shared_ptr<Connection>;
// class Connection : public std::enable_shared_from_this<Connection>
// {
// private:
//     uint64_t _conn_id; // 连接的唯一ID，便于连接的管理和查找
//     // uint64_t _timer_id;   //定时器ID，必须是唯一的，这块为了简化操作使用conn_id作为定时器ID
//     int _sockfd;                   // 连接关联的文件描述符
//     bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false
//     EventLoop *_loop;              // 连接所关联的一个EventLoop
//     ConnStatu _statu;              // 连接状态
//     Socket _socket;                // 套接字操作管理
//     Channel _channel;              // 连接的事件管理
//     Buffer _in_buffer;             // 输入缓冲区---存放从socket中读取到的数据
//     Buffer _out_buffer;            // 输出缓冲区---存放要发送给对端的数据
//     Any _context;                  // 请求的接收处理上下文

//     /*这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）*/
//     /*换句话说，这几个回调都是组件使用者使用的*/
//     using ConnectedCallback = std::function<void(const PtrConnection &)>;
//     using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
//     using ClosedCallback = std::function<void(const PtrConnection &)>;
//     using AnyEventCallback = std::function<void(const PtrConnection &)>;
//     ConnectedCallback _connected_callback;
//     MessageCallback _message_callback;
//     ClosedCallback _closed_callback;
//     AnyEventCallback _event_callback;
//     /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
//     /*就应该从管理的地方移除掉自己的信息*/
//     ClosedCallback _server_closed_callback;

// private:
//     /*五个channel的事件回调函数*/
//     // 描述符可读事件触发后调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
//     void HandleRead()
//     {
//         // 1. 接收socket的数据，放到缓冲区
//         char buf[65536];
//         ssize_t ret = _socket.NonBlockRecv(buf, 65535);
//         if (ret < 0)
//         {
//             // 出错了,不能直接关闭连接
//             return ShutdownInLoop();
//         }
//         // 这里的等于0表示的是没有读取到数据，而并不是连接断开了，连接断开返回的是-1
//         // 将数据放入输入缓冲区,写入之后顺便将写偏移向后移动
//         _in_buffer.WriteAndPush(buf, ret);
//         // 2. 调用message_callback进行业务处理
//         if (_in_buffer.ReadableSize() > 0)
//         {
//             // shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
//             return _message_callback(shared_from_this(), &_in_buffer);
//         }
//     }
//     // 描述符可写事件触发后调用的函数，将发送缓冲区中的数据进行发送
//     void HandleWrite()
//     {
//         //_out_buffer中保存的数据就是要发送的数据
//         ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadableSize());
//         if (ret < 0)
//         {
//             // 发送错误就该关闭连接了，
//             if (_in_buffer.ReadableSize() > 0)
//             {
//                 _message_callback(shared_from_this(), &_in_buffer);
//             }
//             return Release(); // 这时候就是实际的关闭释放操作了。
//         }
//         _out_buffer.MoveReadOffset(ret); // 千万不要忘了，将读偏移向后移动
//         if (_out_buffer.ReadableSize() == 0)
//         {
//             _channel.DisableWrite(); // 没有数据待发送了，关闭写事件监控
//             // 如果当前是连接待关闭状态，则有数据，发送完数据释放连接，没有数据则直接释放
//             if (_statu == DISCONNECTING)
//             {
//                 return Release();
//             }
//         }
//         return;
//     }
//     // 描述符触发挂断事件
//     void HandleClose()
//     {
//         /*一旦连接挂断了，套接字就什么都干不了了，因此有数据待处理就处理一下，完毕关闭连接*/
//         if (_in_buffer.ReadableSize() > 0)
//         {
//             _message_callback(shared_from_this(), &_in_buffer);
//         }
//         return Release();
//     }
//     // 描述符触发出错事件
//     void HandleError()
//     {
//         return HandleClose();
//     }
//     // 描述符触发任意事件: 1. 刷新连接的活跃度--延迟定时销毁任务；  2. 调用组件使用者的任意事件回调
//     void HandleEvent()
//     {
//         if (_enable_inactive_release == true)
//         {
//             _loop->TimerRefresh(_conn_id);
//         }
//         if (_event_callback)
//         {
//             _event_callback(shared_from_this());
//         }
//     }
//     // 连接获取之后，所处的状态下要进行各种设置（启动读监控,调用回调函数）
//     void EstablishedInLoop()
//     {
//         // 1. 修改连接状态；  2. 启动读事件监控；  3. 调用回调函数
//         assert(_statu == CONNECTING); // 当前的状态必须一定是上层的半连接状态
//         _statu = CONNECTED;           // 当前函数执行完毕，则连接进入已完成连接状态
//         // 一旦启动读事件监控就有可能会立即触发读事件，如果这时候启动了非活跃连接销毁
//         _channel.EnableRead();
//         if (_connected_callback)
//             _connected_callback(shared_from_this());
//     }
//     // 这个接口才是实际的释放接口
//     void ReleaseInLoop()
//     {
//         // 1. 修改连接状态，将其置为DISCONNECTED
//         _statu = DISCONNECTED;
//         // 2. 移除连接的事件监控
//         _channel.Remove();
//         // 3. 关闭描述符
//         _socket.Close();
//         // 4. 如果当前定时器队列中还有定时销毁任务，则取消任务
//         if (_loop->HasTimer(_conn_id))
//             CancelInactiveReleaseInLoop();
//         // 5. 调用关闭回调函数，避免先移除服务器管理的连接信息导致Connection被释放，再去处理会出错，因此先调用用户的回调函数
//         if (_closed_callback)
//             _closed_callback(shared_from_this());
//         // 移除服务器内部管理的连接信息
//         if (_server_closed_callback)
//             _server_closed_callback(shared_from_this());
//     }
//     // 这个接口并不是实际的发送接口，而只是把数据放到了发送缓冲区，启动了可写事件监控
//     void SendInLoop(Buffer &buf)
//     {
//         if (_statu == DISCONNECTED)
//             return;
//         _out_buffer.WriteBufferAndPush(buf);
//         if (_channel.WriteAble() == false)
//         {
//             _channel.EnableWrite();
//         }
//     }
//     // 这个关闭操作并非实际的连接释放操作，需要判断还有没有数据待处理，待发送
//     void ShutdownInLoop()
//     {
//         _statu = DISCONNECTING; // 设置连接为半关闭状态
//         if (_in_buffer.ReadableSize() > 0)
//         {
//             if (_message_callback)
//                 _message_callback(shared_from_this(), &_in_buffer);
//         }
//         // 要么就是写入数据的时候出错关闭，要么就是没有待发送数据，直接关闭
//         if (_out_buffer.ReadableSize() > 0)
//         {
//             if (_channel.WriteAble() == false)
//             {
//                 _channel.EnableWrite();
//             }
//         }
//         if (_out_buffer.ReadableSize() == 0)
//         {
//             Release();
//         }
//     }
//     // 启动非活跃连接超时释放规则
//     void EnableInactiveReleaseInLoop(int sec)
//     {
//         // 1. 将判断标志 _enable_inactive_release 置为true
//         _enable_inactive_release = true;
//         // 2. 如果当前定时销毁任务已经存在，那就刷新延迟一下即可
//         if (_loop->HasTimer(_conn_id))
//         {
//             return _loop->TimerRefresh(_conn_id);
//         }
//         // 3. 如果不存在定时销毁任务，则新增
//         _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
//     }
//     void CancelInactiveReleaseInLoop()
//     {
//         _enable_inactive_release = false;
//         if (_loop->HasTimer(_conn_id))
//         {
//             _loop->TimerCancel(_conn_id);
//         }
//     }
//     void UpgradeInLoop(const Any &context,
//                        const ConnectedCallback &conn,
//                        const MessageCallback &msg,
//                        const ClosedCallback &closed,
//                        const AnyEventCallback &event)
//     {
//         _context = context;
//         _connected_callback = conn;
//         _message_callback = msg;
//         _closed_callback = closed;
//         _event_callback = event;
//     }

// public:
//     Connection(EventLoop *loop, uint64_t conn_id, int sockfd) : _conn_id(conn_id), _sockfd(sockfd),
//                                                                 _enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(_sockfd),
//                                                                 _channel(loop, _sockfd)
//     {
//         _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
//         _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
//         _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
//         _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
//         _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
//     }
//     ~Connection() { DBG_LOG("RELEASE CONNECTION:%p", this); }
//     // 获取管理的文件描述符
//     int Fd() { return _sockfd; }
//     // 获取连接ID
//     int Id() { return _conn_id; }
//     // 是否处于CONNECTED状态
//     bool Connected() { return (_statu == CONNECTED); }
//     // 设置上下文--连接建立完成时进行调用
//     void SetContext(const Any &context) { _context = context; }
//     // 获取上下文，返回的是指针
//     Any *GetContext() { return &_context; }
//     void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
//     void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
//     void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
//     void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
//     void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }
//     // 连接建立就绪后，进行channel回调设置，启动读监控，调用_connected_callback
//     void Established()
//     {
//         _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
//     }
//     // 发送数据，将数据放到发送缓冲区，启动写事件监控
//     void Send(const char *data, size_t len)
//     {
//         // 外界传入的data，可能是个临时的空间，我们现在只是把发送操作压入了任务池，有可能并没有被立即执行
//         // 因此有可能执行的时候，data指向的空间有可能已经被释放了。
//         Buffer buf;
//         buf.WriteAndPush(data, len);
//         _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
//     }
//     // 提供给组件使用者的关闭接口--并不实际关闭，需要判断有没有数据待处理
//     void Shutdown()
//     {
//         _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
//     }
//     void Release()
//     {
//         _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
//     }
//     // 启动非活跃销毁，并定义多长时间无通信就是非活跃，添加定时任务
//     void EnableInactiveRelease(int sec)
//     {
//         _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
//     }
//     // 取消非活跃销毁
//     void CancelInactiveRelease()
//     {
//         _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
//     }
//     // 切换协议---重置上下文以及阶段性回调处理函数 -- 而是这个接口必须在EventLoop线程中立即执行
//     // 防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了。
//     void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
//                  const ClosedCallback &closed, const AnyEventCallback &event)
//     {
//         _loop->AssertInLoop();
//         _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
//     }
// };

// class Acceptor
// {
// private:
//     Socket _socket;   // 创建监听套接字
//     EventLoop *_loop; // 对监听套接字进行事件监控
//     Channel _channel; // 对监听套接字进行事件管理

//     using AcceptCallback = std::function<void(int)>;
//     AcceptCallback _accept_callback;

// private:
//     // 监听套接字的读事件回调函数--获取新连接 调用_accept_callback进行新连接处理
//     void HandleRead()
//     {
//         int newfd = _socket.Accept();
//         if (newfd < 0)
//         {
//             DBG_LOG("accept error");
//             return;
//         }
//         if (_accept_callback)
//             _accept_callback(newfd);
//     }
//     int CreateServer(uint16_t port)
//     {
//         bool ret = _socket.CreateServer(port);
//         assert(ret == true);
//         return _socket.Fd();
//     }

// public:
//     Acceptor(EventLoop *loop, uint16_t port)
//         : _socket(CreateServer(port)),
//           _loop(loop),
//           _channel(_loop, _socket.Fd())
//     {
//         _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
//     }
//     void SetAcceptCallback(const AcceptCallback &cb)
//     {
//         _accept_callback = cb;
//     }

//     void Listen()
//     {
//         _channel.EnableRead();
//     }
// };

// using Functor = std::function<void()>;

// class TcpServer
// {
// private:
//     uint16_t _port;
//     uint64_t _next_id;
//     int _timeout;
//     bool _enable_inactive_release;
//     EventLoop _baseloop;
//     Acceptor _acceptor;

//     LoopThreadPool _pool;
//     std::unordered_map<uint64_t, PtrConnection> _conns;

//     using ConnectedCallback = std::function<void(const PtrConnection &)>;
//     using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
//     using ClosedCallback = std::function<void(const PtrConnection &)>;
//     using AnyEventCallback = std::function<void(const PtrConnection &)>;
//     ConnectedCallback _connected_callback;
//     MessageCallback _message_callback;
//     ClosedCallback _closed_callback;
//     AnyEventCallback _event_callback;

// private:
//     void NewConnection(int fd)
//     {
//         _next_id++;
//         PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));

//         conn->SetMessageCallback(_message_callback);
//         conn->SetClosedCallback(_closed_callback);
//         conn->SetConnectedCallback(_connected_callback);
//         conn->SetAnyEventCallback(_event_callback);
//         conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));

//         if (_enable_inactive_release)
//             conn->EnableInactiveRelease(_timeout);

//         conn->Established(); // 就绪初始化

//         _conns.insert({_next_id, conn});
//     }

//     void RemoveConnectionInLoop(const PtrConnection &conn)
//     {
//         int id = conn->Id();
//         auto it = _conns.find(id);
//         if (it != _conns.end())
//             _conns.erase(it);
//     }

//     void RemoveConnection(const PtrConnection &conn)
//     {
//         _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
//     }
//     void RunAfterInLoop(const Functor &task, int delay)
//     {
//         _next_id++;
//         _baseloop.TimerAdd(_next_id, delay, task);
//     }

// public:
//     TcpServer(uint16_t port)
//         : _port(port),
//           _next_id(0),
//           _enable_inactive_release(false),
//           _acceptor(&_baseloop, port),
//           _pool(&_baseloop)
//     {

//         _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
//         _acceptor.Listen();
//     }
//     void SetThreadCount(int count)
//     {
//         _pool.SetThreadCount(count);
//     }
//     void Start()
//     {
//         _pool.Create();
//         _baseloop.Start();
//     }
//     void RunAfter(const Functor &task, int delay)
//     {
//         _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
//     }
//     void SetEnableInactiveRelease(int timeout)
//     {
//         _timeout = timeout;
//         _enable_inactive_release = true;
//     }
//     void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
//     void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
//     void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
//     void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
// };

// DISCONNECTED: 连接关闭状态
// CONNECTING: 连接建立成功 待处理状态
// CONNECTED: 连接建立完成 各种设置已完成 可以通信的状态
// DISCONNECTED: 待关闭状态
// typedef enum
// {
//     DISCONNECTED,
//     CONNECTING,
//     CONNECTED,
//     DISCONNECTING
// } ConnStatu;

// class Connection;
// using PtrConnection = std::shared_ptr<Connection>;
// class Connection : public std::enable_shared_from_this<Connection>
// {
// private:
//     uint64_t _conn_id;             // 连接唯一的ID 便于连接的管理和查找
//     int _sockfd;                   // 连接关联的文件描述符
//     Socket _socket;                // 套接字操作管理
//     bool _enable_inactive_release; // 连接是否启动非活跃连接释放的标志
//     EventLoop *_loop;
//     ConnStatu _statu;   // 连接的状态
//     Channel _channel;   // 连接的事件管理
//     Buffer _in_buffer;  // 输入缓冲区  存放从socket中读取到的数据
//     Buffer _out_buffer; // 输出缓冲区  存放要发送给对端的数据
//     Any _context;       // 请求的接收处理的上下文

//     using ConnectedCallback = std::function<void(const PtrConnection &)>;
//     using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
//     using ClosedCallback = std::function<void(const PtrConnection &)>;
//     using AnyEventCallback = std::function<void(const PtrConnection &)>;
//     ConnectedCallback _connected_callback;
//     MessageCallback _message_callback;
//     // 组件使用者设置的
//     ClosedCallback _closed_callback;
//     AnyEventCallback _event_callback;

//     // 组件内的事件关闭回调--组件内设置的
//     // 服务器组件会把所有连接管理起来 一旦某个连接要关闭了 就应该从管理的地方移除掉自己的信息
//     ClosedCallback _server_closed_callback;

// private:
//     // 五个channel的回调函数
//     // 读事件回调 接收socket数据放到接收缓冲区中 然后调用_message_callback
//     void HandleRead()
//     {
//         // 1.从socket中接收数据 放到接收缓冲区中
//         char buf[65536];
//         int ret = _socket.NonBlockRecv(buf, 65535);
//         if (ret < 0) // 出错了 不能直接关闭连接 要看看缓冲区中是否还有数据
//         {
//             return ShutDownInLoop();
//         }

//         _in_buffer.WriteAndPush(buf, ret);

//         // 2.调用_message_callback进行业务处理
//         if (_in_buffer.ReadableSize() > 0)
//             _message_callback(shared_from_this(), &_in_buffer);
//     }
//     // 写事件回调 将发送缓冲区中的数据发送
//     void HandleWrite()
//     {
//         int ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadableSize());
//         if (ret < 0) // 出错了 要关闭连接 (实际关闭)
//         {
//             // 如果还有数据 则处理完数据再关闭连接
//             if (_in_buffer.ReadableSize() > 0)
//                 _message_callback(shared_from_this(), &_in_buffer);
//             return Release();
//         }

//         _out_buffer.MoveReadOffset(ret);
//         if (_out_buffer.ReadableSize() == 0) // 如果没有数据待发送了
//         {
//             _channel.DisableWrite();     // 关闭写事件监控 防止一直触发写事件 导致busyloop
//             if (_statu == DISCONNECTING) // 如果连接处于待关闭状态 有数据则发送 无数据则关闭连接
//             {
//                 return Release();
//             }
//         }
//     }
//     // 挂断事件回调
//     void HandleClose()
//     {
//         // 一旦触发挂断 就什么都做不了了
//         if (_in_buffer.ReadableSize() > 0)
//             _message_callback(shared_from_this(), &_in_buffer);
//         return Release();
//     }
//     // 错误事件回调
//     void HandleError()
//     {
//         HandleClose();
//     }
//     // 任意事件回调
//     void HandleEvent()
//     {
//         // 1.刷新连接的活跃度--延迟定时任务
//         if (_enable_inactive_release == true)
//             _loop->TimerRefresh(_conn_id);
//         // 2.调用组件使用者设置的任意回调函数
//         if (_event_callback)
//             _event_callback(shared_from_this());
//     }
//     void SendInLoop(Buffer &buf)
//     {
//         if (_statu == DISCONNECTED)
//             return;
//         // 1把数据放到发送缓冲区中
//         _out_buffer.WriteBufferAndPush(buf);
//         // 2.启动写事件监控
//         if (_channel.WriteAble() == false)
//             _channel.EnableWrite();
//     }
//     void EstablishedInLoop()
//     {
//         // 1.修改连接状态
//         assert(_statu == CONNECTING);
//         _statu = CONNECTED;
//         // 2.启动读事件监控
//         _channel.EnableRead();
//         // 3.执行回调函数
//         if (_connected_callback)
//             _connected_callback(shared_from_this());
//     }
//     void ReleaseInLoop()
//     {
//         // 1.修改连接状态 将其置为DISCONNECTED
//         _statu = DISCONNECTED;
//         // 2.移除连接的事件监控
//         _channel.Remove();
//         // 3.关闭描述符
//         _socket.Close();
//         // 4.如果当前定时器任务队列中好友定时销毁任务 则取消任务
//         if (_loop->HasTimer(_conn_id))
//             CancleInactiveReleaseInLoop();
//         // 5.调用关闭回调函数 先调用组件使用者设置的关闭回调 否则可能会提前释放连接 导致出错
//         if (_closed_callback)
//             _closed_callback(shared_from_this());
//         if (_server_closed_callback)
//             _server_closed_callback(shared_from_this());
//     }
//     void ShutDownInLoop()
//     {
//         // 1.修改连接状态
//         _statu = DISCONNECTING;
//         // 2.判断是否有数据待处理 待发送
//         if (_in_buffer.ReadableSize() > 0)
//         {
//             if (_message_callback)
//                 _message_callback(shared_from_this(), &_in_buffer);
//         }

//         if (_out_buffer.ReadableSize() > 0)
//         {
//             if (_channel.WriteAble() == false)
//                 _channel.EnableWrite();
//         }

//         // 没有数据发送 直接关闭
//         if (_out_buffer.ReadableSize() == 0)
//             Release();
//     }
//     void EnableInactiveReleaseInLoop(int sec)
//     {
//         // 1.把判断标志 置为true
//         _enable_inactive_release = true;
//         // 2.如果当前定时销毁任务已存在 则刷新
//         if (_loop->HasTimer(_conn_id))
//             _loop->TimerRefresh(_conn_id);
//         else
//             _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
//         // 3.如果当前定时销毁任务不存在 则添加
//     }
//     void CancleInactiveReleaseInLoop()
//     {
//         _enable_inactive_release = false;
//         if (_loop->HasTimer(_conn_id))
//             _loop->TimerCancel(_conn_id);
//     }
//     void UpGradeInLoop(const Any &context, const ConnectedCallback &conn,
//                        const MessageCallback &msg,
//                        const ClosedCallback &closed,
//                        const AnyEventCallback &event)
//     {
//         _context = context;
//         _connected_callback = conn;
//         _message_callback = msg;
//         _closed_callback = closed;
//         _event_callback = event;
//     }

// public:
//     Connection(EventLoop *loop, uint64_t conn_id, int sockfd)
//         : _loop(loop),
//           _conn_id(conn_id),
//           _socket(sockfd),
//           _enable_inactive_release(false),
//           _statu(CONNECTING),
//           _channel(loop, _sockfd)
//     {
//         _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
//         _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
//         _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
//         _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
//         _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
//     }
//     ~Connection()
//     {
//         DBG_LOG("~Connection()");
//     }
//     int Fd()
//     {
//         return _sockfd;
//     }

//     uint64_t Id()
//     {
//         return _conn_id;
//     }

//     // 设置上下文
//     void SetContext(const Any &context)
//     {
//         _context = context;
//     }

//     // 获取上下文
//     Any *GetContext()
//     {
//         return &_context;
//     }

//     bool Connected()
//     {
//         return _statu == CONNECTED;
//     }

//     ConnStatu Statu()
//     {
//         return _statu;
//     }

//     void SetConnectedCallback(const ConnectedCallback &cb)
//     {
//         _connected_callback = cb;
//     }

//     void SetMessageCallback(const MessageCallback &cb)
//     {
//         _message_callback = cb;
//     }

//     void SetClosedCallback(const ClosedCallback &cb)
//     {
//         _closed_callback = cb;
//     }

//     void SetSvrClosedCallback(const ClosedCallback &cb)
//     {
//         _server_closed_callback = cb;
//     }

//     void SetAnyEventCallback(const AnyEventCallback &cb)
//     {
//         _event_callback = cb;
//     }

//     // 连接获取之后，即CONNECTING状态，进行各种设置 给Channel设置回调 启动读监控 调用_conn_callback
//     void Established()
//     {
//         _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
//     }

//     // 发送数据到发送缓冲区 启动写事件监控
//     void Send(const char *data, int len)
//     {
//         Buffer buf;
//         buf.WriteAndPush(data, len);
//         _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
//     }

//     void Release()
//     {
//         _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
//     }

//     // 提供给组件使用者的关闭接口 并不实际关闭 需要判断缓冲区有没有数据待处理
//     void ShutDown()
//     {
//         _loop->RunInLoop(std::bind(&Connection::ShutDownInLoop, this));
//     }

//     // 启动非活跃连接超时销毁
//     void EnableInactiveRelease(int sec)
//     {
//         _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
//     }

//     // 取消非活跃连接超时销毁
//     void CancleInactiveRelease()
//     {
//         _loop->RunInLoop(std::bind(&Connection::CancleInactiveReleaseInLoop, this));
//     }

//     // 协议切换 重置上下文以及阶段性处理函数
//     // 这个函数必须再EventLoop中执行
//     // 防备新的事件触发后 处理的时候 切换任务还没有被执行 导致数据使用原协议处理
//     void UpGrade(const Any &context, const ConnectedCallback &conn,
//                  const MessageCallback &msg,
//                  const ClosedCallback &closed,
//                  const AnyEventCallback &event)
//     {
//         _loop->AssertInLoop();
//         _loop->RunInLoop(std::bind(&Connection::UpGradeInLoop, this, context, conn, msg, closed, event));
//     }
// };

// void Channel::Remove()
// {
//     _loop->RemoveEvent(this);
// }

// void Channel::Update()
// {
//     _loop->UpdateEvent(this);
// }

// // 添加定时任务
// void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
// {
//     _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
// }
// // 刷新/延迟定时任务
// void TimerWheel::TimerRefresh(uint64_t id)
// {
//     _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
// }

// // 取消定时任务
// void TimerWheel::TimerCancel(uint64_t id)
// {
//     _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
// }

// class NetWork
// {
// public:
//     NetWork()
//     {
//         DBG_LOG("NetWork()");
//         // 当连接断开时 如果还在继续发送数据 则会触发SIGPIPE信号 发送一个异常导致进程退出
//         // 忽略掉这个信号哦
//         signal(SIGPIPE, SIG_IGN);
//     }
// };

// static NetWork nw;

#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL DBG

#define LOG(level, format, ...)                                                                                        \
    do                                                                                                                 \
    {                                                                                                                  \
        if (level < LOG_LEVEL)                                                                                         \
            break;                                                                                                     \
        time_t t = time(NULL);                                                                                         \
        struct tm *ltm = localtime(&t);                                                                                \
        char tmp[32] = {0};                                                                                            \
        strftime(tmp, 31, "%H:%M:%S", ltm);                                                                            \
        fprintf(stdout, "[%p %s %s:%d] " format "\n", (void *)pthread_self(), tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)

#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
private:
    std::vector<char> _buffer; // 使用vector进行内存空间管理
    uint64_t _reader_idx;      // 读偏移
    uint64_t _writer_idx;      // 写偏移
public:
    Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    char *Begin() { return &*_buffer.begin(); }
    // 获取当前写入起始地址, _buffer的空间起始地址，加上写偏移量
    char *WritePosition() { return Begin() + _writer_idx; }
    // 获取当前读取起始地址
    char *ReadPosition() { return Begin() + _reader_idx; }
    // 获取缓冲区末尾空闲空间大小--写偏移之后的空闲空间, 总体空间大小减去写偏移
    uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
    // 获取缓冲区起始空闲空间大小--读偏移之前的空闲空间
    uint64_t HeadIdleSize() { return _reader_idx; }
    // 获取可读数据大小 = 写偏移 - 读偏移
    uint64_t ReadableSize() { return _writer_idx - _reader_idx; }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 向后移动的大小，必须小于可读数据大小
        assert(len <= ReadableSize());
        _reader_idx += len;
    }
    // 将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        // 向后移动的大小，必须小于当前后边的空闲空间大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空间足够（整体空闲空间够了就移动数据，否则就扩容）
    void EnsureWriteSpace(uint64_t len)
    {
        // 如果末尾空闲空间大小足够，直接返回
        if (TailIdleSize() >= len)
        {
            return;
        }
        // 末尾空闲空间不够，则判断加上起始位置的空闲空间大小是否足够, 够了就将数据移动到起始位置
        if (len <= TailIdleSize() + HeadIdleSize())
        {
            // 将数据移动到起始位置
            uint64_t rsz = ReadableSize();                            // 把当前数据大小先保存起来
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin()); // 把可读数据拷贝到起始位置
            _reader_idx = 0;                                          // 将读偏移归0
            _writer_idx = rsz;                                        // 将写位置置为可读数据大小， 因为当前的可读数据大小就是写偏移量
        }
        else
        {
            // 总体空间不够，则需要扩容，不移动数据，直接给写偏移之后扩容足够空间即可
            DBG_LOG("RESIZE %ld", _writer_idx + len);
            _buffer.resize(_writer_idx + len);
        }
    }
    // 写入数据
    void Write(const void *data, uint64_t len)
    {
        // 1. 保证有足够空间，2. 拷贝数据进去
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }
    void WriteString(const std::string &data)
    {
        return Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    void WriteBuffer(Buffer &data)
    {
        return Write(data.ReadPosition(), data.ReadableSize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadableSize());
    }
    // 读取数据
    void Read(void *buf, uint64_t len)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(len <= ReadableSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
    }
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }
    std::string ReadAsString(uint64_t len)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(len <= ReadableSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);
        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadableSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }
    char *FindCRLF()
    {
        char *res = (char *)memchr(ReadPosition(), '\n', ReadableSize());
        return res;
    }
    /*通常获取一行数据，这种情况针对是*/
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == NULL)
        {
            return "";
        }
        // +1是为了把换行字符也取出来。
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }
    // 清空缓冲区
    void Clear()
    {
        // 只需要将偏移量归0即可
        _reader_idx = 0;
        _writer_idx = 0;
    }
};

#define MAX_LISTEN 1024
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd() { return _sockfd; }
    // 创建套接字
    bool Create()
    {
        // int socket(int domain, int type, int protocol)
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ERR_LOG("CREATE SOCKET FAILED!!");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int bind(int sockfd, struct sockaddr*addr, socklen_t len);
        int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("BIND ADDRESS FAILED!");
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        // int listen(int backlog)
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            ERR_LOG("SOCKET LISTEN FAILED!");
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int connect(int sockfd, struct sockaddr*addr, socklen_t len);
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("CONNECT SERVER FAILED!");
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept()
    {
        // int accept(int sockfd, struct sockaddr *addr, socklen_t *len);
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            ERR_LOG("SOCKET ACCEPT FAILED!");
            return -1;
        }
        return newfd;
    }
    // 接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        // ssize_t recv(int sockfd, void *buf, size_t len, int flag);
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // EAGAIN 当前socket的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR  表示当前socket的阻塞等待，被信号打断了，
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示这次接收没有接收到数据
            }
            ERR_LOG("SOCKET RECV FAILED!!");
            return -1;
        }
        return ret; // 实际接收的数据长度
    }
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞。
    }
    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        // ssize_t send(int sockfd, void *data, size_t len, int flag);
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            ERR_LOG("SOCKET SEND FAILED!!");
            return -1;
        }
        return ret; // 实际发送的数据长度
    }
    ssize_t NonBlockSend(void *buf, size_t len)
    {
        if (len == 0)
            return 0;
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前发送为非阻塞。
    }
    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
    {
        // 1. 创建套接字，2. 绑定地址，3. 开始监听，4. 设置非阻塞， 5. 启动地址重用
        if (Create() == false)
            return false;
        if (block_flag)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;
        ReuseAddress();
        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        // 1. 创建套接字，2.指向连接服务器
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 设置套接字选项---开启地址端口重用
    void ReuseAddress()
    {
        // int setsockopt(int fd, int leve, int optname, void *val, int vallen)
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
    }
    // 设置套接字阻塞属性-- 设置为非阻塞
    void NonBlock()
    {
        // int fcntl(int fd, int cmd, ... /* arg */ );
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};

class Poller;
class EventLoop;
class Channel
{
private:
    int _fd;
    EventLoop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开事件被触发的回调函数
    EventCallback _event_callback; // 任意事件被触发的回调函数
public:
    Channel(EventLoop *loop, int fd) : _fd(fd), _events(0), _revents(0), _loop(loop) {}
    int Fd() { return _fd; }
    uint32_t Events() { return _events; }                   // 获取想要监控的事件
    void SetREvents(uint32_t events) { _revents = events; } // 设置实际就绪的事件
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    // 当前是否监控了可读
    bool Readable() { return (_events & EPOLLIN); }
    // 当前是否监控了可写
    bool WriteAble() { return (_events & EPOLLOUT); }
    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 移除监控
    void Remove();
    void Update();
    // 事件处理，一旦连接触发了事件，就调用这个函数，自己触发了什么事件如何处理自己决定
    void HandleEvent()
    {
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            /*不管任何事件，都调用的回调函数*/
            if (_read_callback)
                _read_callback();
        }
        /*有可能会释放连接的操作事件，一次只处理一个*/
        if (_revents & EPOLLOUT)
        {
            if (_write_callback)
                _write_callback();
        }
        else if (_revents & EPOLLERR)
        {
            if (_error_callback)
                _error_callback(); // 一旦出错，就会释放连接，因此要放到前边调用任意回调
        }
        else if (_revents & EPOLLHUP)
        {
            if (_close_callback)
                _close_callback();
        }
        if (_event_callback)
            _event_callback();
    }
};
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;

private:
    // 对epoll的直接操作
    void Update(Channel *channel, int op)
    {
        // int epoll_ctl(int epfd, int op,  int fd,  struct epoll_event *ev);
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            ERR_LOG("EPOLLCTL FAILED!");
        }
        return;
    }
    // 判断一个Channel是否已经添加了事件监控
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            return false;
        }
        return true;
    }

public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            ERR_LOG("EPOLL CREATE FAILED!!");
            abort(); // 退出程序
        }
    }
    // 添加或修改监控事件
    void UpdateEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            // 不存在则添加
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 移除监控
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it);
        }
        Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控，返回活跃连接
    void Poll(std::vector<Channel *> *active)
    {
        // int epoll_wait(int epfd, struct epoll_event *evs, int maxevents, int timeout)
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (nfds < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("EPOLL WAIT ERROR:%s\n", strerror(errno));
            abort(); // 退出程序
        }
        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events); // 设置实际就绪的事件
            active->push_back(it->second);
        }
        return;
    }
};

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask
{
private:
    uint64_t _id;         // 定时器任务对象ID
    uint32_t _timeout;    // 定时任务的超时时间
    bool _canceled;       // false-表示没有被取消， true-表示被取消
    TaskFunc _task_cb;    // 定时器对象要执行的定时任务
    ReleaseFunc _release; // 用于删除TimerWheel中保存的定时器对象信息
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb) : _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
    ~TimerTask()
    {
        if (_canceled == false)
            _task_cb();
        _release();
    }
    void Cancel() { _canceled = true; }
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; }
};

class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimerTask>;
    using PtrTask = std::shared_ptr<TimerTask>;
    int _tick;     // 当前的秒针，走到哪里释放哪里，释放哪里，就相当于执行哪里的任务
    int _capacity; // 表盘最大数量---其实就是最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;
    std::unordered_map<uint64_t, WeakTask> _timers;

    EventLoop *_loop;
    int _timerfd; // 定时器描述符--可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timer_channel;

private:
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            _timers.erase(it);
        }
    }
    static int CreateTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            ERR_LOG("TIMERFD CREATE FAILED!");
            abort();
        }
        // int timerfd_settime(int fd, int flags, struct itimerspec *new, struct itimerspec *old);
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0; // 第一次超时时间为1s后
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0; // 第一次超时后，每次超时的间隔时
        timerfd_settime(timerfd, 0, &itime, NULL);
        return timerfd;
    }
    int ReadTimefd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            ERR_LOG("READ TIMEFD FAILED!");
            abort();
        }
        return times;
    }
    // 这个函数应该每秒钟被执行一次，相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
    }
    void OnTime()
    {
        // 根据实际超时的次数，执行对应的超时任务
        int times = ReadTimefd();
        for (int i = 0; i < times; i++)
        {
            RunTimerTask();
        }
    }
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        PtrTask pt(new TimerTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _timers[id] = WeakTask(pt);
    }
    void TimerRefreshInLoop(uint64_t id)
    {
        // 通过保存的定时器对象的weak_ptr构造一个shared_ptr出来，添加到轮子中
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找着定时任务，没法刷新，没法延迟
        }
        PtrTask pt = it->second.lock(); // lock获取weak_ptr管理的对象对应的shared_ptr
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找着定时任务，没法刷新，没法延迟
        }
        PtrTask pt = it->second.lock();
        if (pt)
            pt->Cancel();
    }

public:
    TimerWheel(EventLoop *loop) : _capacity(60), _tick(0), _wheel(_capacity), _loop(loop),
                                  _timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead(); // 启动读事件监控
    }
    /*定时器中有个_timers成员，定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全问题*/
    /*如果不想加锁，那就把对定期的所有操作，都放到一个线程中进行*/
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    // 刷新/延迟定时任务
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id);
    /*这个接口存在线程安全问题--这个接口实际上不能被外界使用者调用，只能在模块内，在对应的EventLoop线程内执行*/
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return false;
        }
        return true;
    }
};

class EventLoop
{
private:
    using Functor = std::function<void()>;
    std::thread::id _thread_id; // 线程ID
    int _event_fd;              // eventfd唤醒IO事件监控有可能导致的阻塞
    std::unique_ptr<Channel> _event_channel;
    Poller _poller;              // 进行所有描述符的事件监控
    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex;           // 实现任务池操作的线程安全
    TimerWheel _timer_wheel;     // 定时器模块
public:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(functor);
        }
        for (auto &f : functor)
        {
            f();
        }
        return;
    }
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            ERR_LOG("CREATE EVENTFD FAILED!!");
            abort(); // 让程序异常退出
        }
        return efd;
    }
    void ReadEventfd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            // EINTR -- 被信号打断；   EAGAIN -- 表示无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }
    void WeakUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }

public:
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _event_fd(CreateEventFd()),
                  _event_channel(new Channel(this, _event_fd)),
                  _timer_wheel(this)
    {
        // 给eventfd添加可读事件回调函数，读取eventfd事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));
        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }
    // 三步走--事件监控-》就绪事件处理-》执行任务
    void Start()
    {
        while (1)
        {
            // 1. 事件监控，
            std::vector<Channel *> actives;
            _poller.Poll(&actives);
            // 2. 事件处理。
            for (auto &channel : actives)
            {
                channel->HandleEvent();
            }
            // 3. 执行任务
            RunAllTask();
        }
    }
    // 用于判断当前线程是否是EventLoop对应的线程；
    bool IsInLoop()
    {
        return (_thread_id == std::this_thread::get_id());
    }
    void AssertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }
    // 判断将要执行的任务是否处于当前线程中，如果是则执行，不是则压入队列。
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
        {
            return cb();
        }
        return QueueInLoop(cb);
    }
    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞；
        // 其实就是给eventfd写入一个数据，eventfd就会触发可读事件
        WeakUpEventFd();
    }
    // 添加/修改描述符的事件监控
    void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); }
    // 移除描述符的监控
    void RemoveEvent(Channel *channel) { return _poller.RemoveEvent(channel); }
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { return _timer_wheel.TimerAdd(id, delay, cb); }
    void TimerRefresh(uint64_t id) { return _timer_wheel.TimerRefresh(id); }
    void TimerCancel(uint64_t id) { return _timer_wheel.TimerCancel(id); }
    bool HasTimer(uint64_t id) { return _timer_wheel.HasTimer(id); }
};
class LoopThread
{
private:
    /*用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop*/
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop *_loop;              // EventLoop指针变量，这个对象需要在线程内实例化
    std::thread _thread;           // EventLoop对应的线程
private:
    /*实例化 EventLoop 对象，唤醒_cond上有可能阻塞的线程，并且开始运行EventLoop模块的功能*/
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }

public:
    /*创建线程，设定线程入口函数*/
    LoopThread() : _loop(NULL), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    /*返回当前线程关联的EventLoop对象指针*/
    EventLoop *GetLoop()
    {
        EventLoop *loop = NULL;
        {
            std::unique_lock<std::mutex> lock(_mutex); // 加锁
            _cond.wait(lock, [&]()
                       { return _loop != NULL; }); // loop为NULL就一直阻塞
            loop = _loop;
        }
        return loop;
    }
};

class LoopThreadPool
{
private:
    int _thread_count;
    int _next_idx;
    EventLoop *_baseloop;
    std::vector<LoopThread *> _threads;
    std::vector<EventLoop *> _loops;

public:
    LoopThreadPool(EventLoop *baseloop) : _thread_count(0), _next_idx(0), _baseloop(baseloop) {}
    void SetThreadCount(int count) { _thread_count = count; }
    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
        return;
    }
    EventLoop *NextLoop()
    {
        if (_thread_count == 0)
        {
            return _baseloop;
        }
        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }
};

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info &type() { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() { return new placeholder(_val); }

    public:
        T _val;
    };
    holder *_content;

public:
    Any() : _content(NULL) {}
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    Any(const Any &other) : _content(other._content ? other._content->clone() : NULL) {}
    ~Any() { delete _content; }

    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回子类对象保存的数据的指针
    template <class T>
    T *get()
    {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        return &((placeholder<T> *)_content)->_val;
    }
    // 赋值运算符的重载函数
    template <class T>
    Any &operator=(const T &val)
    {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
        Any(val).swap(*this);
        return *this;
    }
    Any &operator=(const Any &other)
    {
        Any(other).swap(*this);
        return *this;
    }
};

class Connection;
// DISCONECTED -- 连接关闭状态；   CONNECTING -- 连接建立成功-待处理状态
// CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态；  DISCONNECTING -- 待关闭状态
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatu;
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id; // 连接的唯一ID，便于连接的管理和查找
    // uint64_t _timer_id;   //定时器ID，必须是唯一的，这块为了简化操作使用conn_id作为定时器ID
    int _sockfd;                   // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false
    EventLoop *_loop;              // 连接所关联的一个EventLoop
    ConnStatu _statu;              // 连接状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buffer;             // 输入缓冲区---存放从socket中读取到的数据
    Buffer _out_buffer;            // 输出缓冲区---存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文

    /*这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）*/
    /*换句话说，这几个回调都是组件使用者使用的*/
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
    /*就应该从管理的地方移除掉自己的信息*/
    ClosedCallback _server_closed_callback;

private:
    /*五个channel的事件回调函数*/
    // 描述符可读事件触发后调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
    void HandleRead()
    {
        // 1. 接收socket的数据，放到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0)
        {
            // 出错了,不能直接关闭连接
            return ShutdownInLoop();
        }
        // 这里的等于0表示的是没有读取到数据，而并不是连接断开了，连接断开返回的是-1
        // 将数据放入输入缓冲区,写入之后顺便将写偏移向后移动
        _in_buffer.WriteAndPush(buf, ret);
        // 2. 调用message_callback进行业务处理
        if (_in_buffer.ReadableSize() > 0)
        {
            // shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }
    // 描述符可写事件触发后调用的函数，将发送缓冲区中的数据进行发送
    void HandleWrite()
    {
        //_out_buffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadableSize());
        if (ret < 0)
        {
            // 发送错误就该关闭连接了，
            if (_in_buffer.ReadableSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release(); // 这时候就是实际的关闭释放操作了。
        }
        _out_buffer.MoveReadOffset(ret); // 千万不要忘了，将读偏移向后移动
        if (_out_buffer.ReadableSize() == 0)
        {
            _channel.DisableWrite(); // 没有数据待发送了，关闭写事件监控
            // 如果当前是连接待关闭状态，则有数据，发送完数据释放连接，没有数据则直接释放
            if (_statu == DISCONNECTING)
            {
                return Release();
            }
        }
        return;
    }
    // 描述符触发挂断事件
    void HandleClose()
    {
        /*一旦连接挂断了，套接字就什么都干不了了，因此有数据待处理就处理一下，完毕关闭连接*/
        if (_in_buffer.ReadableSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }
    // 描述符触发出错事件
    void HandleError()
    {
        return HandleClose();
    }
    // 描述符触发任意事件: 1. 刷新连接的活跃度--延迟定时销毁任务；  2. 调用组件使用者的任意事件回调
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id);
        }
        if (_event_callback)
        {
            _event_callback(shared_from_this());
        }
    }
    // 连接获取之后，所处的状态下要进行各种设置（启动读监控,调用回调函数）
    void EstablishedInLoop()
    {
        // 1. 修改连接状态；  2. 启动读事件监控；  3. 调用回调函数
        assert(_statu == CONNECTING); // 当前的状态必须一定是上层的半连接状态
        _statu = CONNECTED;           // 当前函数执行完毕，则连接进入已完成连接状态
        // 一旦启动读事件监控就有可能会立即触发读事件，如果这时候启动了非活跃连接销毁
        _channel.EnableRead();
        if (_connected_callback)
            _connected_callback(shared_from_this());
    }
    // 这个接口才是实际的释放接口
    void ReleaseInLoop()
    {
        // 1. 修改连接状态，将其置为DISCONNECTED
        _statu = DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3. 关闭描述符
        _socket.Close();
        // 4. 如果当前定时器队列中还有定时销毁任务，则取消任务
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();
        // 5. 调用关闭回调函数，避免先移除服务器管理的连接信息导致Connection被释放，再去处理会出错，因此先调用用户的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }
    // 这个接口并不是实际的发送接口，而只是把数据放到了发送缓冲区，启动了可写事件监控
    void SendInLoop(Buffer &buf)
    {
        if (_statu == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buf);
        if (_channel.WriteAble() == false)
        {
            _channel.EnableWrite();
        }
    }
    // 这个关闭操作并非实际的连接释放操作，需要判断还有没有数据待处理，待发送
    void ShutdownInLoop()
    {
        _statu = DISCONNECTING; // 设置连接为半关闭状态
        if (_in_buffer.ReadableSize() > 0)
        {
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        }
        // 要么就是写入数据的时候出错关闭，要么就是没有待发送数据，直接关闭
        if (_out_buffer.ReadableSize() > 0)
        {
            if (_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }
        if (_out_buffer.ReadableSize() == 0)
        {
            Release();
        }
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1. 将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 2. 如果当前定时销毁任务已经存在，那就刷新延迟一下即可
        if (_loop->HasTimer(_conn_id))
        {
            return _loop->TimerRefresh(_conn_id);
        }
        // 3. 如果不存在定时销毁任务，则新增
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }
    void UpgradeInLoop(const Any &context,
                       const ConnectedCallback &conn,
                       const MessageCallback &msg,
                       const ClosedCallback &closed,
                       const AnyEventCallback &event)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

public:
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd) : _conn_id(conn_id), _sockfd(sockfd),
                                                                _enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(_sockfd),
                                                                _channel(loop, _sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }
    ~Connection() { DBG_LOG("RELEASE CONNECTION:%p", this); }
    // 获取管理的文件描述符
    int Fd() { return _sockfd; }
    // 获取连接ID
    int Id() { return _conn_id; }
    // 是否处于CONNECTED状态
    bool Connected() { return (_statu == CONNECTED); }
    // 设置上下文--连接建立完成时进行调用
    void SetContext(const Any &context) { _context = context; }
    // 获取上下文，返回的是指针
    Any *GetContext() { return &_context; }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }
    // 连接建立就绪后，进行channel回调设置，启动读监控，调用_connected_callback
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }
    // 发送数据，将数据放到发送缓冲区，启动写事件监控
    void Send(const char *data, size_t len)
    {
        // 外界传入的data，可能是个临时的空间，我们现在只是把发送操作压入了任务池，有可能并没有被立即执行
        // 因此有可能执行的时候，data指向的空间有可能已经被释放了。
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 提供给组件使用者的关闭接口--并不实际关闭，需要判断有没有数据待处理
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }
    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }
    // 启动非活跃销毁，并定义多长时间无通信就是非活跃，添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }
    // 切换协议---重置上下文以及阶段性回调处理函数 -- 而是这个接口必须在EventLoop线程中立即执行
    // 防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了。
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                 const ClosedCallback &closed, const AnyEventCallback &event)
    {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};

class Acceptor
{
private:
    Socket _socket;   // 用于创建监听套接字
    EventLoop *_loop; // 用于对监听套接字进行事件监控
    Channel _channel; // 用于对监听套接字进行事件管理

    using AcceptCallback = std::function<void(int)>;
    AcceptCallback _accept_callback;

private:
    /*监听套接字的读事件回调处理函数---获取新连接，调用_accept_callback函数进行新连接处理*/
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if (newfd < 0)
        {
            return;
        }
        if (_accept_callback)
            _accept_callback(newfd);
    }
    int CreateServer(int port)
    {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }

public:
    /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
    /*否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
    Acceptor(EventLoop *loop, int port) : _socket(CreateServer(port)), _loop(loop),
                                          _channel(loop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
    void Listen() { _channel.EnableRead(); }
};

class TcpServer
{
private:
    uint64_t _next_id; // 这是一个自动增长的连接ID，
    int _port;
    int _timeout;                                       // 这是非活跃连接的统计时间---多长时间无通信就是非活跃连接
    bool _enable_inactive_release;                      // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _baseloop;                                // 这是主线程的EventLoop对象，负责监听事件的处理
    Acceptor _acceptor;                                 // 这是监听套接字的管理对象
    LoopThreadPool _pool;                               // 这是从属EventLoop线程池
    std::unordered_map<uint64_t, PtrConnection> _conns; // 保存管理所有连接对应的shared_ptr对象

    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    using Functor = std::function<void()>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;

private:
    void RunAfterInLoop(const Functor &task, int delay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }
    // 为新连接构造一个Connection进行管理
    void NewConnection(int fd)
    {
        _next_id++;
        PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetConnectedCallback(_connected_callback);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release)
            conn->EnableInactiveRelease(_timeout); // 启动非活跃超时销毁
        conn->Established();                       // 就绪初始化
        _conns.insert(std::make_pair(_next_id, conn));
    }
    void RemoveConnectionInLoop(const PtrConnection &conn)
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end())
        {
            _conns.erase(it);
        }
    }
    // 从管理Connection的_conns中移除连接信息
    void RemoveConnection(const PtrConnection &conn)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

public:
    TcpServer(int port) : _port(port),
                          _next_id(0),
                          _enable_inactive_release(false),
                          _acceptor(&_baseloop, port),
                          _pool(&_baseloop)
    {
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen(); // 将监听套接字挂到baseloop上
    }
    void SetThreadCount(int count) { return _pool.SetThreadCount(count); }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void EnableInactiveRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    // 用于添加一个定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void Start()
    {
        _pool.Create();
        _baseloop.Start();
    }
};

void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }
void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}
// 刷新/延迟定时任务
void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

class NetWork
{
public:
    NetWork()
    {
        DBG_LOG("SIGPIPE INIT");
        signal(SIGPIPE, SIG_IGN);
    }
};
static NetWork nw;
